Delete Operation (Replica A):
  1. User clicks "delete" on character at position X
  2. Local state: mark character as invisible
  3. Generate operation:
     - char_id: [encrypted LSEQ position of target]
     - op_type: DELETE
     - lamport_clock: increment counter
     - replica_id: unique replica ID

  4. Generate Delete Proof (Halo2):
     - Witness (secret, only prover knows):
       - Target LSEQ identifier (plaintext)
       - Replica's M²-ORE secret key
       - Visibility permission (is replica authorized?)
       - Merkle path in document tree (membership proof)

     - Public Input (visible to server):
       - Encrypted target position
       - Merkle root of current document
       - Replica ID

     - Halo2 verifies (without decryption):
       ✓ Position is valid LSEQ identifier
       ✓ Merkle path proves membership in document
       ✓ Replica has authorization (signature check)
       ✓ No double-deletion (state machine)

  5. Sign operation with Dilithium
  6. Broadcast: {DELETE, encrypted_id, proof, signature}

Server - Merge Phase:
  1. Receive DELETE operation
  2. Verify Dilithium signature: ✓ Operation is authentic
  3. Verify Halo2 proof (blind): ✓ Deletion is authorized
  4. Verify Lamport clock: ✓ Causally consistent
  5. Lookup character by encrypted_id:
     - Find document_value where char_id = encrypted_id
  6. Mark as invisible:
     - document_value.visible = false
     - timestamp_deleted = now()
     - deleted_by = replica_id
  7. Broadcast: DELETE operation to other replicas

Other Replicas - Receive Phase:
  1. Receive DELETE operation
  2. Verify Halo2 proof (same as server)
  3. Local lookup by encrypted_id
  4. Mark as invisible
  5. Re-render document: invisible characters hidden from user

Character States:
  - VISIBLE: visible: true
    - Render to user
    - Can be deleted
    - Transition: VISIBLE → DELETED

  - DELETED: visible: false
    - Hidden from user
    - Can't be deleted again (idempotent)
    - Kept for causal consistency
    - Transition: DELETED → VISIBLE (undelete, future feature)

Deletion Idempotency:
  - Operation 1: DELETE char_id=100 (visible → deleted)
  - Operation 2: DELETE char_id=100 (already deleted, no-op)
  - Result: ✓ No double-deletion errors

Document Represented as Merkle Tree:
  - Leaves: (char_id, content, visible, timestamp)
  - Hashes: SHA256(left_hash || right_hash)

Delete Proof Circuit:
  - Witness: Merkle path from leaf to root
  - Public: Root hash, char_id
  - Prove: "char_id is in this Merkle tree at root"
  - Path length: ~20 hashes for 1M characters
  - Proof constraints: ~50 per level × 20 levels = 1000 constraints

Advantage: Constant-size proofs regardless of document size!
  - 1,000 character document: proof ~400 bytes
  - 1,000,000 character document: proof ~400 bytes
  - Only Merkle path (20 hashes) differs, not full document

Scenario: Two replicas simultaneously delete and insert same position

Timeline:
  t=0: Original doc: [A, B, C]

  t=1: Replica 1 → DELETE B
       Replica 2 → INSERT X between B and C

Case 1 - Replica 1 deletes first (receives operation first):
  t=1.5 (R1): receive DELETE B → mark B invisible
  t=2 (R1): receive INSERT X at [B.id, C.id]
  t=2.5 (R1): But B is invisible! Insert X after invisible B
  Result: [A, B(invisible), X, C]
  Render: [A, X, C] ✓

Case 2 - Replica 2 inserts first:
  t=1 (R1): receive INSERT X at [B.id, C.id] → [A, B, X, C]
  t=1.5 (R1): receive DELETE B → mark B invisible
  Result: [A, B(invisible), X, C]
  Render: [A, X, C] ✓

Invariant: LSEQ ordering + visibility flags ensure consistent view
regardless of operation arrival order (CRDT commutativity)

// Undelete: restore character without re-insertion
fn propose_undelete(char_id: EncryptedLSEQIdentifier) -> Operation {
    Operation {
        op_type: UNDELETE,
        char_id,
        proof: generate_undelete_proof(),
        signature: sign_operation(),
    }
}

// Server-side:
// 1. Verify Halo2 proof (same Merkle membership check)
// 2. Verify character is marked DELETED (not already visible)
// 3. Set visible = true, timestamp_restored = now()
// 4. Broadcast to replicas

// Audit trail preserved:
// - Who deleted (Dilithium sig)
// - When deleted (timestamp_deleted)
// - Who undeleted (Dilithium sig)
// - When undeleted (timestamp_restored)